package schedule

import (
	"context"
	"fmt"
	"log"
	"math"
	"strconv"
	"strings"
	"sync"
	"time"

	"WHY_GIN/config"
	"WHY_GIN/models"
	"WHY_GIN/service"
	"WHY_GIN/utils"

	"github.com/adshao/go-binance/v2"
)

// GridMode 网格模式类型
type GridMode string

const (
	GridModeFixed GridMode = "fixed" // 固定网格模式
	GridModeSmart GridMode = "smart" // 智能网格模式
)

// PauseReason 暂停原因类型
type PauseReason string

const (
	PauseReasonStopLoss         PauseReason = "stop_loss"         // 止损触发
	PauseReasonSupportBreakdown PauseReason = "support_breakdown" // 支撑位跌破
	PauseReasonCombined         PauseReason = "combined"          // 组合原因（止损+支撑位）
)

// DogeTradeScheduler DOGE/USDT交易对定时任务调度器
type DogeTradeScheduler struct {
	client           *binance.Client
	symbol           string
	isRunning        bool
	stopChan         chan bool
	gridPercent      float64
	usdtAmount       float64 // 每次交易的USDT金额
	lastPrice        float64 // 上次交易价格
	priceFilter      *binance.PriceFilter
	forecastService  *service.DogeUSDTForecastService // DOGE预测服务
	gridMode         GridMode                         // 网格模式：fixed(固定) 或 smart(智能)
	fixedGridPercent float64                          // 固定网格模式下的网格间距
	gridLevels       int                              // 网格层级数量，默认5，范围1-10

	// 买单暂停状态管理
	buyOrdersPaused   bool          // 是否暂停买单
	buyPauseStartTime time.Time     // 买单暂停开始时间
	buyPauseDuration  time.Duration // 买单暂停持续时长
	buyPauseReason    PauseReason   // 暂停原因
	stopLossTriggered bool          // 是否已触发止损
	buyPauseMutex     sync.RWMutex  // 买单暂停状态读写锁
}

// DogeSchedulerConfig DOGE调度器配置
type DogeSchedulerConfig struct {
	GridMode         GridMode `json:"grid_mode"`          // 网格模式："fixed" 或 "smart"
	FixedGridPercent float64  `json:"fixed_grid_percent"` // 固定网格间距（仅在固定模式下使用）
	UsdtAmount       float64  `json:"usdt_amount"`        // 每次交易的USDT金额，默认40.0
	GridLevels       int      `json:"grid_levels"`        // 网格层级数量，默认5，范围1-10
}

// NewDogeTradeScheduler 创建新的DOGE交易调度器
func NewDogeTradeScheduler() *DogeTradeScheduler {
	return NewDogeTradeSchedulerWithConfig(DogeSchedulerConfig{
		GridMode: GridModeSmart, // 默认智能网格模式
	})
}

// NewDogeTradeSchedulerWithConfig 使用配置创建新的DOGE交易调度器
func NewDogeTradeSchedulerWithConfig(schedulerConfig DogeSchedulerConfig) *DogeTradeScheduler {
	// 从配置文件读取 Binance API 密钥
	apiKey := config.Cfg.Binance.APIKey
	secretKey := config.Cfg.Binance.SecretKey
	useTestnet := config.Cfg.Binance.UseTestnet

	// 验证API密钥是否已配置
	if apiKey == "" || secretKey == "" {
		log.Fatal("[ERROR] Binance API密钥未配置，请检查config.yaml文件")
	}

	// 根据配置设置网络模式
	if useTestnet {
		binance.UseTestnet = true
		fmt.Println("[INFO] 调度器使用测试网络模式")
	} else {
		fmt.Println("[INFO] 调度器使用正式网络模式")
	}

	// 创建币安客户端
	client := binance.NewClient(apiKey, secretKey)

	// 初始化时间同步
	timeSyncManager := utils.GetTimeSyncManager()
	timeSyncManager.AutoSync(client)

	// 创建DOGE预测服务
	forecastService := service.NewDogeUSDTForecastService(client)

	// 验证固定网格模式的参数
	if schedulerConfig.GridMode == GridModeFixed {
		if schedulerConfig.FixedGridPercent <= 0 || schedulerConfig.FixedGridPercent > 0.1 {
			log.Fatal("[ERROR] 固定网格间距必须在0-10%之间")
		}
		fmt.Printf("[INFO] 使用固定网格模式，网格间距: %.2f%%\n", schedulerConfig.FixedGridPercent*100)
	} else {
		fmt.Println("[INFO] 使用智能网格模式，将根据预测评分动态调整")
	}

	// 验证USDT交易金额参数
	usdtAmount := schedulerConfig.UsdtAmount
	if usdtAmount <= 0 {
		usdtAmount = 40.0 // 默认40 USDT
		fmt.Printf("[INFO] 使用默认交易金额: %.2f USDT\n", usdtAmount)
	} else if usdtAmount < 20.0 {
		log.Fatal("[ERROR] 交易金额不能小于20 USDT")
	} else {
		fmt.Printf("[INFO] 使用配置的交易金额: %.2f USDT\n", usdtAmount)
	}

	// 验证网格层级参数
	gridLevels := schedulerConfig.GridLevels
	if gridLevels <= 0 {
		gridLevels = 5 // 默认5层
		fmt.Printf("[INFO] 使用默认网格层级: %d层\n", gridLevels)
	} else if gridLevels < 1 || gridLevels > 10 {
		log.Fatal("[ERROR] 网格层级必须在1-10之间")
	} else {
		fmt.Printf("[INFO] 使用配置的网格层级: %d层\n", gridLevels)
	}

	// 根据网格模式设置初始网格间距
	var initialGridPercent float64
	if schedulerConfig.GridMode == GridModeFixed {
		initialGridPercent = schedulerConfig.FixedGridPercent
	} else {
		initialGridPercent = 0.013 // 智能模式默认1.3%
	}

	scheduler := &DogeTradeScheduler{
		client:           client,
		symbol:           "DOGEUSDT",
		isRunning:        false,
		stopChan:         make(chan bool),
		gridPercent:      initialGridPercent,
		usdtAmount:       usdtAmount,
		lastPrice:        0,
		forecastService:  forecastService,
		gridMode:         schedulerConfig.GridMode,
		fixedGridPercent: schedulerConfig.FixedGridPercent,
		gridLevels:       gridLevels,

		// 初始化买单暂停状态
		buyOrdersPaused:   false,
		buyPauseDuration:  8 * time.Hour, // 默认暂停8小时
		buyPauseReason:    "",
		stopLossTriggered: false,
	}

	// 注册为止损事件监听器
	if service.GlobalStopLossEventService != nil {
		service.GlobalStopLossEventService.AddListener(scheduler)
		log.Printf("[DOGE_SCHEDULER] 已注册为止损事件监听器")
	} else {
		log.Printf("[DOGE_SCHEDULER] 警告: 止损事件服务未初始化，无法注册监听器")
	}

	return scheduler
}

// getGridPercentByForecast 根据网格模式和预测评分获取网格间距
func (s *DogeTradeScheduler) getGridPercentByForecast() float64 {
	// 固定网格模式：直接返回固定间距
	if s.gridMode == GridModeFixed {
		fmt.Printf("[DEBUG] 固定网格模式，使用网格间距: %.2f%%\n", s.fixedGridPercent*100)
		return s.fixedGridPercent
	}

	// 智能网格模式：根据预测评分动态调整
	// 如果预测服务未初始化或数据未准备就绪，使用默认值
	if s.forecastService == nil || !s.forecastService.IsDataReady() {
		fmt.Printf("[DEBUG] 预测服务未就绪，使用默认网格间距: 1.3%%\n")
		return 0.013
	}

	// 获取预测评分
	score, err := s.forecastService.CalculateScore()
	if err != nil {
		fmt.Printf("[ERROR] 获取预测评分失败: %v，使用默认网格间距\n", err)
		return 0.013
	}

	scorePercent := score.ScorePercent
	fmt.Printf("[INFO] 当前预测评分: %.2f%% - %s\n", scorePercent, score.Recommendation)

	// 根据评分调整网格间距
	switch {
	case scorePercent >= 80 && scorePercent <= 100:
		// 80-100分：网格间距1.3%
		fmt.Printf("[INFO] 评分%.2f%%，设置网格间距为1.3%%\n", scorePercent)
		return 0.013
	case scorePercent >= 60 && scorePercent < 80:
		// 60-79分：网格间距1.3%
		fmt.Printf("[INFO] 评分%.2f%%，设置网格间距为1.3%%\n", scorePercent)
		return 0.013
	case scorePercent >= 40 && scorePercent < 60:
		// 40-59分：网格间距1.0%
		fmt.Printf("[INFO] 评分%.2f%%，设置网格间距为1.0%%\n", scorePercent)
		return 0.01
	case scorePercent >= 20 && scorePercent < 40:
		// 20-39分：网格间距0.5%
		fmt.Printf("[INFO] 评分%.2f%%，设置网格间距为0.5%%\n", scorePercent)
		return 0.005
	default:
		// 高于80分或低于20分：使用默认间距（但会在交易逻辑中特殊处理）
		fmt.Printf("[INFO] 评分%.2f%%，特殊评分区间，使用默认网格间距\n", scorePercent)
		return 0.013
	}
}

// Start 启动定时任务
func (s *DogeTradeScheduler) Start() error {
	if s.isRunning {
		return fmt.Errorf("调度器已在运行中")
	}

	fmt.Println("[INFO] 启动DOGE/USDT定时交易调度器...")

	// 同步服务器时间
	timeSyncManager := utils.GetTimeSyncManager()
	err := timeSyncManager.SyncWithBinanceServer(s.client)
	if err != nil {
		return fmt.Errorf("服务器时间同步失败: %v", err)
	}
	fmt.Println("[SUCCESS] 服务器时间同步完成")

	// 获取交易对信息
	err = s.initTradingPairInfo()
	if err != nil {
		return fmt.Errorf("初始化交易对信息失败: %v", err)
	}

	// 获取初始价格
	s.lastPrice, err = s.getCurrentPrice()
	if err != nil {
		return fmt.Errorf("获取初始价格失败: %v", err)
	}
	fmt.Printf("[INFO] 初始价格: %.8f USDT\n", s.lastPrice)

	// 初始化预测服务
	if s.forecastService != nil {
		fmt.Println("[INFO] 正在初始化DOGE预测服务...")
		err = s.forecastService.InitializeData()
		if err != nil {
			fmt.Printf("[WARNING] 预测服务初始化失败: %v，将使用默认网格间距\n", err)
		} else {
			fmt.Println("[SUCCESS] DOGE预测服务初始化完成")
		}
	}

	s.isRunning = true

	// 启动定时任务
	go s.runScheduler()

	fmt.Println("[SUCCESS] DOGE/USDT定时交易调度器已启动，每1秒检查一次交易条件")
	return nil
}

//每秒钟获取一次doge价格，记录当天最高价格及

// Stop 停止定时任务
func (s *DogeTradeScheduler) Stop() {
	if !s.isRunning {
		fmt.Println("[INFO] 调度器未在运行")
		return
	}

	fmt.Println("[INFO] 正在停止DOGE/USDT定时交易调度器...")
	s.isRunning = false
	s.stopChan <- true
	fmt.Println("[SUCCESS] DOGE/USDT定时交易调度器已停止")
}

// runScheduler 运行定时调度器
func (s *DogeTradeScheduler) runScheduler() {
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ticker.C:
			// 记录当前网格间距
			oldGridPercent := s.gridPercent
			// 根据预测评分动态调整网格间距
			s.gridPercent = s.getGridPercentByForecast()

			// 检测网格间距变化
			if oldGridPercent != s.gridPercent && oldGridPercent != 0 {
				fmt.Printf("[INFO] 网格间距从%.3f%%调整为%.3f%%\n", oldGridPercent*100, s.gridPercent*100)
			}

			// 检查交易条件并执行交易
			err := s.checkAndExecuteTrade()
			if err != nil {
				fmt.Printf("[ERROR] 交易检查执行失败: %v\n", err)
			}
		case <-s.stopChan:
			fmt.Println("[INFO] 收到停止信号，退出调度器")
			return
		}
	}
}

// checkAndExecuteTrade 检查交易条件并执行交易
func (s *DogeTradeScheduler) checkAndExecuteTrade() error {
	// 获取当前价格
	currentPrice, err := s.getCurrentPrice()
	if err != nil {
		return fmt.Errorf("获取当前价格失败: %v", err)
	}

	// 计算价格变化百分比
	priceChangePercent := (currentPrice - s.lastPrice) / s.lastPrice

	fmt.Printf("[DEBUG] 当前价格: %.8f, 上次价格: %.8f, 变化: %.4f%%\n",
		currentPrice, s.lastPrice, priceChangePercent*100)

	// 检查是否触发交易条件
	if s.shouldTriggerTrade(priceChangePercent) {
		fmt.Printf("[INFO] 触发交易条件，价格变化: %.4f%%\n", priceChangePercent*100)

		// 执行网格交易
		err = s.executeGridTrade(currentPrice)
		if err != nil {
			fmt.Printf("[ERROR] 网格交易执行失败: %v\n", err)
			// 检查是否是余额不足错误，如果是则更新基准价格避免重复触发
			if strings.Contains(err.Error(), "USDT余额不足") {
				s.lastPrice = currentPrice
				fmt.Printf("[INFO] 余额不足，更新基准价格为: %.8f 避免重复触发\n", currentPrice)
			}
			return err
		}

		// 交易执行成功后更新基准价格（只有成交时才更新lastPrice）
		s.lastPrice = currentPrice
		fmt.Printf("[SUCCESS] 交易执行完成，更新基准价格为: %.8f\n", currentPrice)
	}

	return nil
}

// shouldTriggerTrade 判断是否应该触发交易
func (s *DogeTradeScheduler) shouldTriggerTrade(priceChangePercent float64) bool {
	// 当价格变化超过网格间隔的一半时触发交易
	triggerThreshold := s.gridPercent / 2

	fmt.Printf("[DEBUG] 网格间距: %.3f%%, 触发阈值: %.3f%%, 价格变化: %.4f%%\n",
		s.gridPercent*100, triggerThreshold*100, priceChangePercent*100)

	// 价格上涨或下跌超过阈值时触发
	shouldTrigger := priceChangePercent > triggerThreshold || priceChangePercent < -triggerThreshold

	if shouldTrigger {
		//fmt.Printf("[DEBUG] 触发交易条件: 价格变化%.4f%% > 阈值%.3f%%\n",
		//	math.Abs(priceChangePercent)*100, triggerThreshold*100)
	} else {
		//fmt.Printf("[DEBUG] 未触发交易: 价格变化%.4f%% <= 阈值%.3f%%\n",
		//	math.Abs(priceChangePercent)*100, triggerThreshold*100)
	}

	return shouldTrigger
}

// executeGridTrade 执行网格交易
func (s *DogeTradeScheduler) executeGridTrade(currentPrice float64) error {
	fmt.Printf("[INFO] 开始执行网格交易，当前价格: %.8f\n", currentPrice)

	// 检查USDT余额是否满足最低要求（20 USDT）
	// 获取账户余额信息
	accountInfo, err := s.client.NewGetAccountService().Do(context.Background())
	if err != nil {
		fmt.Printf("[ERROR] 获取账户信息失败: %v\n", err)
		return fmt.Errorf("获取账户信息失败: %v", err)
	}

	// 查找USDT余额
	var usdtBalance float64
	for _, balance := range accountInfo.Balances {
		if balance.Asset == "USDT" {
			free, parseErr := strconv.ParseFloat(balance.Free, 64)
			if parseErr != nil {
				fmt.Printf("[ERROR] 解析USDT余额失败: %v\n", parseErr)
				return fmt.Errorf("解析USDT余额失败: %v", parseErr)
			}
			usdtBalance = free
			break
		}
	}

	if usdtBalance < 20.0 {
		fmt.Printf("[WARNING] USDT余额不足(%.2f < 20.0)，停止网格交易\n", usdtBalance)
		return fmt.Errorf("USDT余额不足，当前可用余额: %.2f USDT，最低要求: 20.0 USDT", usdtBalance)
	}
	fmt.Printf("[INFO] USDT余额检查通过，当前可用余额: %.2f USDT\n", usdtBalance)

	// 检查是否需要停止交易（高于80分或低于20分时停止所有交易）
	shouldStop := s.shouldStopTrading()
	if shouldStop {
		fmt.Println("[INFO] 当前评分处于特殊区间（>80分或<20分），停止所有交易")
		return nil
	}

	// 网格层数：使用配置的网格层级，形成网格结构
	successfulOrders := 0
	totalOrders := 0

	// 获取最后一条买单价格用于计算卖单价格
	lastBuyPrice, err := s.getLastBuyOrderPrice()
	if err != nil {
		fmt.Printf("[WARNING] 获取最后一条买单价格失败: %v，使用当前价格计算卖单\n", err)
		lastBuyPrice = currentPrice
	}

	// 循环执行网格交易，每次在不同价格层级下单
	for i := 1; i <= s.gridLevels; i++ {
		// 计算每层的价格偏移（逐层递增）
		priceOffset := float64(i) * s.gridPercent

		// 生成买单价格
		buyPrice := currentPrice * (1 - priceOffset)
		
		// 修正卖单价格计算逻辑：卖单单位价格=对应交易对最后一条买单的价格*网格间距FixedGridPercent
		var sellPrice float64
		if s.gridMode == GridModeFixed {
			// 固定网格模式：使用固定网格间距
			sellPrice = lastBuyPrice * (1 + s.fixedGridPercent)
		} else {
			// 智能网格模式：使用当前网格间距
			sellPrice = lastBuyPrice * (1 + s.gridPercent)
		}

		// 验证价格有效性
		if buyPrice <= 0 {
			fmt.Printf("[WARNING] 第%d层买入价格无效: %.8f，跳过此层\n", i, buyPrice)
			continue
		}

		// 根据USDT金额计算对应的DOGE数量（DOGE步长为1，需要向下取整）
		buyQuantity := math.Floor(s.usdtAmount / buyPrice)
		// 基于卖单价格计算卖单数量
		sellQuantity := math.Floor(s.usdtAmount / sellPrice)

		// 验证数量有效性
		if buyQuantity <= 0 {
			fmt.Printf("[WARNING] 第%d层买入数量计算结果无效: %.0f DOGE，跳过买单\n", i, buyQuantity)
		} else {
			// 检查买单是否被暂停
			if s.isBuyOrdersPaused() {
				fmt.Printf("[INFO] 第%d层买单被暂停: 因止损事件暂停买单中\n", i)
			} else {
				// 下买单
				fmt.Printf("[INFO] 第%d层买单: %s @ %.8f USDT, 目标金额: %.2f USDT, 数量: %.0f DOGE\n", i, s.symbol, buyPrice, s.usdtAmount, buyQuantity)
				totalOrders++
				err := s.placeLimitOrderWithQuantity(binance.SideTypeBuy, buyPrice, buyQuantity)
				if err != nil {
					fmt.Printf("[ERROR] 第%d层买单下单失败: %v\n", i, err)
				} else {
					fmt.Printf("[SUCCESS] 第%d层买单下单成功: %s @ %.8f USDT, 数量: %.0f DOGE\n", i, s.symbol, buyPrice, buyQuantity)
					successfulOrders++
				}
			}
		}

		// 下卖单
		if sellQuantity <= 0 {
			fmt.Printf("[WARNING] 第%d层卖出数量计算结果无效: %.0f DOGE，跳过卖单\n", i, sellQuantity)
		} else {
			// 下卖单
			fmt.Printf("[INFO] 第%d层卖单: %s @ %.8f USDT, 目标金额: %.2f USDT, 数量: %.0f DOGE\n", i, s.symbol, sellPrice, s.usdtAmount, sellQuantity)
			totalOrders++
			err := s.placeLimitOrderWithQuantity(binance.SideTypeSell, sellPrice, sellQuantity)
			if err != nil {
				fmt.Printf("[ERROR] 第%d层卖单下单失败: %v\n", i, err)
			} else {
				fmt.Printf("[SUCCESS] 第%d层卖单下单成功: %s @ %.8f USDT, 数量: %.0f DOGE\n", i, s.symbol, sellPrice, sellQuantity)
				successfulOrders++
			}
		}

		// 每层之间添加短暂延迟，避免API限制
		if i < s.gridLevels {
			time.Sleep(100 * time.Millisecond)
		}
	}

	fmt.Printf("[INFO] 网格交易执行完成: 成功下单 %d/%d\n", successfulOrders, totalOrders)
	return nil
}

// shouldStopTrading 判断是否停止交易（仅在智能模式下评分>80或<20时）
func (s *DogeTradeScheduler) shouldStopTrading() bool {
	// 固定网格模式：不停止交易
	if s.gridMode == GridModeFixed {
		return false
	}

	// 智能网格模式：根据预测评分判断
	// 如果预测服务未初始化或数据未准备就绪，返回false（正常交易）
	if s.forecastService == nil || !s.forecastService.IsDataReady() {
		return false
	}

	// 获取预测评分
	score, err := s.forecastService.CalculateScore()
	if err != nil {
		return false
	}

	scorePercent := score.ScorePercent
	// 高于80分或低于20分时停止所有交易
	return scorePercent > 80 || scorePercent < 20
}

// placeLimitOrderWithQuantity 下限价单（支持动态数量）
func (s *DogeTradeScheduler) placeLimitOrderWithQuantity(side binance.SideType, price float64, quantity float64) error {
	// 验证数量有效性
	if quantity <= 0 {
		return fmt.Errorf("无效的交易数量: %.0f DOGE", quantity)
	}
	// 调用service包中的浮点数量下单函数
	return service.PlaceLimitOrderWithFloatQuantity(s.client, s.symbol, side, price, quantity, s.priceFilter.TickSize)
}

// getCurrentPrice 获取当前市场价格
func (s *DogeTradeScheduler) getCurrentPrice() (float64, error) {
	prices, err := s.client.NewListPricesService().Symbol(s.symbol).Do(context.Background())
	if err != nil {
		fmt.Printf("[ERROR] API调用失败: %v\n", err)
		return 0, err
	}

	for _, price := range prices {
		if price.Symbol == s.symbol {
			priceFloat, err := service.ParseFloat(price.Price)
			if err != nil {
				fmt.Printf("[ERROR] 价格解析失败: %s -> %v\n", price.Price, err)
				return 0, err
			}

			// 价格异常检测：如果价格变化超过50%，记录警告并进行二次验证
			if s.lastPrice > 0 {
				changePercent := (priceFloat - s.lastPrice) / s.lastPrice
				if changePercent > 0.5 || changePercent < -0.5 {
					fmt.Printf("[WARNING] 检测到异常价格变化: 从%.8f到%.8f，变化%.2f%%\n",
						s.lastPrice, priceFloat, changePercent*100)

					// 进行二次验证：等待1秒后重新获取价格
					fmt.Printf("[INFO] 进行价格二次验证...\n")
					time.Sleep(1 * time.Second)

					// 重新获取价格进行验证
					verifyPrices, verifyErr := s.client.NewListPricesService().Symbol(s.symbol).Do(context.Background())
					if verifyErr == nil {
						for _, verifyPrice := range verifyPrices {
							if verifyPrice.Symbol == s.symbol {
								verifyPriceFloat, parseErr := service.ParseFloat(verifyPrice.Price)
								if parseErr == nil {
									fmt.Printf("[INFO] 二次验证价格: %.8f\n", verifyPriceFloat)
									// 如果两次价格差异很大，记录警告但仍使用新价格
									if math.Abs(priceFloat-verifyPriceFloat)/priceFloat > 0.1 {
										fmt.Printf("[WARNING] 价格数据不一致，但仍使用新价格: %.8f\n", verifyPriceFloat)
									}
									// 使用验证后的价格
									priceFloat = verifyPriceFloat
								}
								break
							}
						}
					}
				}
			}

			return priceFloat, nil
		}
	}

	return 0, fmt.Errorf("未找到%s的市场价格", s.symbol)
}

// initTradingPairInfo 初始化交易对信息
func (s *DogeTradeScheduler) initTradingPairInfo() error {
	exchangeInfo, err := s.client.NewExchangeInfoService().Symbol(s.symbol).Do(context.Background())
	if err != nil {
		return err
	}

	// 查找价格过滤器
	for _, symbolInfo := range exchangeInfo.Symbols {
		if symbolInfo.Symbol == s.symbol {
			s.priceFilter = symbolInfo.PriceFilter()
			break
		}
	}

	if s.priceFilter == nil {
		return fmt.Errorf("未找到%s的价格过滤器规则", s.symbol)
	}

	fmt.Printf("[INFO] 价格过滤器规则: 最小价格=%s, 最大价格=%s, 价格精度=%s\n",
		s.priceFilter.MinPrice, s.priceFilter.MaxPrice, s.priceFilter.TickSize)

	return nil
}

// IsRunning 检查调度器是否正在运行
func (s *DogeTradeScheduler) IsRunning() bool {
	return s.isRunning
}

// GetStatus 获取调度器状态信息
// OnStopLossTriggered 实现StopLossEventListener接口，处理止损事件
func (s *DogeTradeScheduler) OnStopLossTriggered(event service.StopLossEvent) {
	log.Printf("[DOGE_SCHEDULER] 收到止损事件通知: OrderID=%d, Symbol=%s, LossRate=%.2f%%",
		event.OrderID, event.Symbol, event.LossRate*100)

	// 只处理DOGE相关的止损事件
	if event.Symbol == s.symbol {
		s.pauseBuyOrders()
		log.Printf("[DOGE_SCHEDULER] 因止损事件暂停买单8小时: Symbol=%s", event.Symbol)
	} else {
		log.Printf("[DOGE_SCHEDULER] 忽略非DOGE交易对的止损事件: Symbol=%s", event.Symbol)
	}
}

// OnSupportLevelBreakdown 实现StopLossEventListener接口，处理支撑位跌破事件
func (s *DogeTradeScheduler) OnSupportLevelBreakdown(event service.SupportLevelBreakdownEvent) {
	log.Printf("[DOGE_SCHEDULER] 收到支撑位跌破事件通知: Symbol=%s, SupportLevel=%.6f, CurrentPrice=%.6f, BreakdownRate=%.2f%%",
		event.Symbol, event.SupportLevel, event.CurrentPrice, event.BreakdownRate*100)

	// 只处理DOGE相关的支撑位跌破事件
	if event.Symbol == s.symbol {
		// 支撑位跌破单独触发时暂停24小时
		s.pauseBuyOrdersWithReason(PauseReasonSupportBreakdown, 24*time.Hour)
		log.Printf("[DOGE_SCHEDULER] 因支撑位跌破暂停买单: Symbol=%s, SupportLevel=%.6f, CurrentPrice=%.6f",
			event.Symbol, event.SupportLevel, event.CurrentPrice)
	} else {
		log.Printf("[DOGE_SCHEDULER] 忽略非DOGE交易对的支撑位跌破事件: Symbol=%s", event.Symbol)
	}
}

// pauseBuyOrders 暂停买单8小时（兼容旧接口）
func (s *DogeTradeScheduler) pauseBuyOrders() {
	s.pauseBuyOrdersWithReason(PauseReasonStopLoss, 8*time.Hour)
}

// pauseBuyOrdersWithReason 根据原因暂停买单指定时长
func (s *DogeTradeScheduler) pauseBuyOrdersWithReason(reason PauseReason, duration time.Duration) {
	s.buyPauseMutex.Lock()
	defer s.buyPauseMutex.Unlock()

	// 如果已经暂停，需要根据新的原因调整暂停时长
	if s.buyOrdersPaused {
		// 计算当前暂停的剩余时间
		remaining := s.buyPauseDuration - time.Since(s.buyPauseStartTime)
		if remaining < 0 {
			remaining = 0
		}

		// 根据新的原因调整暂停时长
		switch reason {
		case PauseReasonStopLoss:
			if s.buyPauseReason == PauseReasonSupportBreakdown {
				// 支撑位跌破后又触发止损，在剩余时间基础上再增加16小时
				s.buyPauseDuration = remaining + 16*time.Hour
				s.buyPauseReason = PauseReasonCombined
				s.stopLossTriggered = true
				log.Printf("[DOGE_SCHEDULER] 支撑位跌破后又触发止损，在剩余%.1f小时基础上再增加16小时", remaining.Hours())
			} else {
				// 重复的止损事件，保持原有暂停
				log.Printf("[DOGE_SCHEDULER] 重复的止损事件，保持原有暂停")
				return
			}
		case PauseReasonSupportBreakdown:
			if s.buyPauseReason == PauseReasonStopLoss {
				// 止损后又触发支撑位跌破，在剩余时间基础上再增加16小时
				s.buyPauseDuration = remaining + 16*time.Hour
				s.buyPauseReason = PauseReasonCombined
				log.Printf("[DOGE_SCHEDULER] 止损后又触发支撑位跌破，在剩余%.1f小时基础上再增加16小时", remaining.Hours())
			} else {
				// 重复的支撑位跌破事件，保持原有暂停
				log.Printf("[DOGE_SCHEDULER] 重复的支撑位跌破事件，保持原有暂停")
				return
			}
		}

		// 重新设置暂停开始时间
		s.buyPauseStartTime = time.Now()
	} else {
		// 首次暂停
		s.buyOrdersPaused = true
		s.buyPauseStartTime = time.Now()
		s.buyPauseDuration = duration
		s.buyPauseReason = reason

		if reason == PauseReasonStopLoss {
			s.stopLossTriggered = true
		}
	}

	log.Printf("[DOGE_SCHEDULER] 买单已暂停，原因: %s，开始时间: %s，持续时长: %.1f小时",
		s.buyPauseReason, s.buyPauseStartTime.Format("2006-01-02 15:04:05"), s.buyPauseDuration.Hours())
}

// resumeBuyOrders 恢复买单
func (s *DogeTradeScheduler) resumeBuyOrders() {
	s.buyPauseMutex.Lock()
	defer s.buyPauseMutex.Unlock()

	s.buyOrdersPaused = false
	s.buyPauseStartTime = time.Time{}
	s.buyPauseReason = ""
	s.stopLossTriggered = false
	log.Printf("[DOGE_SCHEDULER] 买单暂停已解除")
}

// isBuyOrdersPaused 检查买单是否处于暂停状态
func (s *DogeTradeScheduler) isBuyOrdersPaused() bool {
	s.buyPauseMutex.RLock()
	defer s.buyPauseMutex.RUnlock()

	if !s.buyOrdersPaused {
		return false
	}

	// 检查暂停时间是否已过期
	if time.Since(s.buyPauseStartTime) >= s.buyPauseDuration {
		// 暂停时间已过期，自动恢复买单
		s.buyPauseMutex.RUnlock()
		s.resumeBuyOrders()
		s.buyPauseMutex.RLock()
		return false
	}

	return true
}

// getBuyPauseStatus 获取买单暂停状态信息
func (s *DogeTradeScheduler) getBuyPauseStatus() map[string]interface{} {
	s.buyPauseMutex.RLock()
	defer s.buyPauseMutex.RUnlock()

	status := map[string]interface{}{
		"paused": s.buyOrdersPaused,
	}

	if s.buyOrdersPaused {
		status["pause_start_time"] = s.buyPauseStartTime.Format("2006-01-02 15:04:05")
		status["pause_duration_hours"] = s.buyPauseDuration.Hours()
		status["pause_reason"] = string(s.buyPauseReason)
		status["stop_loss_triggered"] = s.stopLossTriggered

		// 根据暂停原因提供详细说明
		switch s.buyPauseReason {
		case PauseReasonStopLoss:
			status["reason_description"] = "止损触发，暂停买单8小时"
		case PauseReasonSupportBreakdown:
			status["reason_description"] = "支撑位跌破，暂停买单24小时"
		case PauseReasonCombined:
			status["reason_description"] = "止损和支撑位跌破组合触发，暂停买单24小时"
		default:
			status["reason_description"] = "未知原因"
		}

		remaining := s.buyPauseDuration - time.Since(s.buyPauseStartTime)
		if remaining > 0 {
			status["remaining_hours"] = remaining.Hours()
			status["resume_time"] = s.buyPauseStartTime.Add(s.buyPauseDuration).Format("2006-01-02 15:04:05")
		} else {
			status["remaining_hours"] = 0
			status["resume_time"] = "已过期，即将自动恢复"
		}
	}

	return status
}

// getLastBuyOrderPrice 获取最后一条买单的价格
func (s *DogeTradeScheduler) getLastBuyOrderPrice() (float64, error) {
	var tradeRecord models.TradeRecord
	
	// 查询最后一条买单记录 (ActionType = 1 表示买入)
	err := config.DB.Where("action_type = ?", 1).
		Order("trade_time DESC").
		First(&tradeRecord).Error
	
	if err != nil {
		return 0, fmt.Errorf("未找到买单记录: %v", err)
	}
	
	// 将decimal类型的价格转换为float64
	price, _ := tradeRecord.Price.Float64()
	return price, nil
}

func (s *DogeTradeScheduler) GetStatus() map[string]interface{} {
	status := map[string]interface{}{
		"symbol":           s.symbol,
		"isRunning":        s.isRunning,
		"gridPercent":      s.gridPercent,
		"usdtAmount":       s.usdtAmount,
		"lastPrice":        s.lastPrice,
		"tickSize":         s.priceFilter.TickSize,
		"gridMode":         string(s.gridMode),
		"fixedGridPercent": s.fixedGridPercent,
	}

	// 添加预测评分信息
	if s.forecastService != nil && s.forecastService.IsDataReady() {
		score, err := s.forecastService.CalculateScore()
		if err == nil {
			status["forecastScore"] = score.ScorePercent
			status["recommendation"] = score.Recommendation
			status["stopTrading"] = s.shouldStopTrading()
			status["forecastReady"] = true
		} else {
			status["forecastReady"] = false
			status["forecastError"] = err.Error()
		}
	} else {
		status["forecastReady"] = false
	}

	// 添加买单暂停状态信息
	status["buy_orders_pause_status"] = s.getBuyPauseStatus()

	return status
}
